home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / OpenGL 1.0 SDK / Source / Examples / aux / backtrace / scene.c++ < prev    next >
Encoding:
C/C++ Source or Header  |  1999-05-18  |  25.2 KB  |  1,154 lines  |  [TEXT/CWIE]
  1. /*
  2. * (c) Copyright 1993, 1994, 1995, 1996 Silicon Graphics, Inc.
  3. * ALL RIGHTS RESERVED 
  4. * Permission to use, copy, modify, and distribute this software for 
  5. * any purpose and without fee is hereby granted, provided that the above
  6. * copyright notice appear in all copies and that both the copyright notice
  7. * and this permission notice appear in supporting documentation, and that 
  8. * the name of Silicon Graphics, Inc. not be used in advertising
  9. * or publicity pertaining to distribution of the software without specific,
  10. * written prior permission. 
  11. *
  12. * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
  13. * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
  14. * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
  15. * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
  16. * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
  17. * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
  18. * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
  19. * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
  20. * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
  21. * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
  22. * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  23. * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
  24. * 
  25. * US Government Users Restricted Rights 
  26. * Use, duplication, or disclosure by the Government is subject to
  27. * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
  28. * (c)(1)(ii) of the Rights in Technical Data and Computer Software
  29. * clause at DFARS 252.227-7013 and/or in similar or successor
  30. * clauses in the FAR or the DOD or NASA FAR Supplement.
  31. * Unpublished-- rights reserved under the copyright laws of the
  32. * United States.  Contractor/manufacturer is Silicon Graphics,
  33. * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
  34. *
  35. * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
  36. */
  37. #include "glu.h"
  38. #include "agl.h"
  39. #include "tk.h"
  40.  
  41. #include <math.h>
  42. #include <stdio.h>
  43. #include <stdlib.h>
  44.  
  45. /* XXX */
  46. #include <string.h>
  47.  
  48. /*
  49. extern "C" {
  50. #include <rgb.h>
  51. };
  52. */
  53.  
  54. #include "Unitdisk.h"
  55.  
  56. #include "scene.h"
  57.  
  58. const GLfloat I[16] = {
  59.     1, 0, 0, 0,
  60.     0, 1, 0, 0,
  61.     0, 0, 1, 0,
  62.     0, 0, 0, 1
  63. };
  64.  
  65. Color white;
  66. Color black;
  67.  
  68. #define M_PI  3.14159265359
  69.  
  70. const double M_2PI = 2.0 * M_PI;
  71. const float scene_fudge = .000001;
  72.  
  73. /* Lights are native to the xz plane and are rotated into position - 
  74. * shadows and refraction will not have to be changed if lights are 
  75. * just rotating about the z axis */
  76. light lights[] = {
  77.     {{1, 0, 0, 1}, {0, 0, 0, 0}, {1, 0, 0, 0}, 
  78.     {1, 0, 0, 0,  0, 1, 0, 0,   0, 0, 1, 0,   0, 0, 0, 1},
  79.     "Red", 1},
  80.     {{0, 1, 0, 1}, {0, 0, 0, 0}, {0, 1, 0, 0},
  81.     {1, 0, 0, 0,  0, 1, 0, 0,   0, 0, 1, 0,   0, 0, 0, 1},
  82.     "Green", 1},
  83.     {{0, 0, 1, 1}, {0, 0, 0, 0}, {0, 0, 1, 0},
  84.     {1, 0, 0, 0,  0, 1, 0, 0,   0, 0, 1, 0,   0, 0, 0, 1},
  85.     "Blue", 1}
  86. };
  87.  
  88. GLfloat light_init_position[nlights][4] = 
  89.     {{1.5, 0, 2.5, 1}, {1, 0, 3, 1}, {2, 0, 3, 1}};
  90. GLfloat light_init_rotation[nlights] = {135, 0, 90};
  91. GLfloat light_rotation[nlights];
  92.  
  93. Color world_ambient(.25, .25, .25);
  94.  
  95. GLfloat index = indices[def_refraction_index].index;
  96.  
  97. GLfloat square_ambient[4] = {.25, .25, .25, 1};
  98. GLfloat square_diffuse[4] = {1, 1, 1, 1};
  99. GLfloat square_specular[4] = {0, 0, 0, 1};
  100.  
  101. const GLfloat fov = 45.0;
  102. GLfloat aspect = 1.0;
  103. GLfloat eyep[3] = {-6, 0, 6};
  104. GLfloat lookp[3] = {0, 0, 1};
  105.  
  106.  
  107. /*
  108. static GLXContext glx_context;
  109. */
  110.  
  111. const int max_args = 20;
  112.  
  113. static int list_square;
  114. static int lists_shadows;
  115. static int lists_refraction;
  116. static int lists_lights = 5;
  117. static int list_sphere = 4;
  118. static int list_spheredisk = 9;
  119. static int list_lights_on = 6;
  120. static int list_lights_off = 7;
  121. static int list_light_draw = 8;
  122.  
  123. int draw_square = 1;
  124. int draw_shadows = 1;
  125. int draw_refraction = 1;
  126. int draw_sphere = 1;
  127. int draw_lights = 1;
  128. int draw_texture = 1;
  129.  
  130. int possible_divisions[] = {10, 20, 30, 40};
  131.  
  132. // Sphere is stored as floats - more efficient
  133. GLfloat *spherepts = NULL;
  134. int nspherepts = 0;
  135. int spherediv = 0;
  136. Point_b sphere_position = {0, 0, 1, 1};
  137. GLfloat sphere_size = .5;
  138. const GLfloat sphere_ambient[4] = {0, 0, 0, 0};
  139. const GLfloat sphere_specular[4] = {0, 0, 0, 0};
  140. Unitdisk sphere_disk;
  141. static void sphere_build();
  142. static void sphere_list_init();
  143. static void sphere_draw();
  144.  
  145. static void square_list_init();
  146.  
  147. static void lights_init_onoff();
  148. static void lights_init_position();
  149. static void lights_init_position(int i);
  150. static void lights_list_init2(void);
  151. static void lights_list_init(int n);
  152.  
  153. static void light_draw_list_init();
  154.  
  155. Unitdisk disks[nlights];
  156. int diskdiv = possible_divisions[def_divisions_index];
  157. static void disk_build();
  158. static void disk_build(int disk);
  159.  
  160.  
  161. Unitdisk shadows[nlights];
  162. static void shadow_list_init();
  163. static void shadow_list_init(int n);
  164. static void shadow_draw(int n);
  165.  
  166. Unitdisk refraction[nlights];
  167. static void refraction_list_init();
  168. static void refraction_list_init(int n);
  169.  
  170. static void shadow_refraction_full_build();
  171. static void shadow_refraction_full_build(int n);
  172.  
  173. void scene_init();
  174. static void lists_init();
  175. static void lights_init();
  176. static int lights_move(int light, float dr, float dphi, float dtheta, 
  177. int update);
  178. static void lights_move_update(int light, int dr, int dphi, int dtheta);
  179.  
  180. void scene_draw();
  181.  
  182. void texture_init();
  183.  
  184. TK_RGBImageRec *teximage = NULL;
  185.  
  186. inline float sign(float a) 
  187. {
  188.     // This is badly written so let's not call it too often, ok?
  189.     return (a > 0) ? 1 : (a < 0) ? -1 : 0;
  190. }
  191.  
  192. inline double degrees(double a)
  193. {
  194.     return (a * 180.0 / M_PI);
  195. }
  196.  
  197. inline double radians(double a)
  198. {
  199.     return (a * M_PI / 180.0);
  200. }
  201.  
  202. inline double degrees_clamp(double a)
  203. {
  204.     while (a < 0.0) a += 360.0;
  205.     while (a > 360.0) a -= 360.0;
  206.     return a;
  207. }
  208.  
  209. inline double radians_clamp(double a)
  210. {
  211.     while (a < 0.0) a += M_2PI;
  212.     while (a > M_2PI) a -= M_2PI;
  213.     return a;
  214. }
  215.  
  216. void scene_init()
  217. {
  218.     int i;
  219.  
  220.     white.c[0] = white.c[1] = white.c[2] = white.c[3] = 1;
  221.     black.c[0] = black.c[1] = black.c[2] = 0;
  222.     black.c[3] = 1;
  223.  
  224.     lists_init();
  225.  
  226.  
  227.     for (i = 0; i < nlights; i++) 
  228.     {
  229.         lights[i].pos = light_init_position[i];
  230.         light_rotation[i] = light_init_rotation[i];
  231.         lights_init_position(i);
  232.     }
  233.  
  234.     divisions_change(possible_divisions[def_divisions_index]);
  235.  
  236.     lights_init_onoff();
  237.     lights_init();
  238.     lights_init_position();
  239.  
  240.     texture_init();
  241.  
  242.     glClearStencil(0);
  243.  
  244.     // This is for profiling
  245.     // exit(0);
  246. }
  247.  
  248. static void scene_project()
  249. {
  250.     glMatrixMode(GL_PROJECTION);
  251.     //glLoadIdentity();
  252.     gluPerspective(fov, aspect, 0.01, 20.0);
  253.     //glMatrixMode(GL_MODELVIEW);
  254.     //glLoadIdentity();
  255.     gluLookAt(eyep[0], eyep[1], eyep[2], lookp[0], lookp[1], lookp[2], 1, 0, 0);
  256. }
  257.  
  258. static void scene_rasterize()
  259. {
  260.     int i;
  261.  
  262.     glLoadName(name_square);
  263.     
  264.     if (draw_square) 
  265.     {
  266.         if (draw_texture) glEnable(GL_TEXTURE_2D);
  267.         //glCallList(list_square);
  268.         square_list_init();
  269.         glDisable(GL_TEXTURE_2D);
  270.     }
  271.     
  272.     if (draw_shadows) 
  273.     {
  274.         for (i = 0; i < nlights; i++) 
  275.         {
  276.             if (lights[i].on) 
  277.             {
  278.                 glPushMatrix();
  279.                 glRotatef(-light_rotation[i], 0, 0, 1);
  280.                 glCallList(lists_shadows + i);
  281.                 glPopMatrix();
  282.             }
  283.         }
  284.     }
  285.     
  286.     if (draw_refraction)
  287.     {
  288.         for (i = 0; i < nlights; i++) 
  289.         {
  290.             if (lights[i].on) 
  291.             {
  292.                 glPushMatrix();
  293.                 glRotatef(-light_rotation[i], 0, 0, 1);
  294.                 glCallList(lists_refraction + i);
  295.                 glPopMatrix();
  296.             }
  297.         }
  298.     }
  299.  
  300.     glLoadName(name_sphere);
  301.     /* Drawing the sphere here makes the sphere visible through itself when we
  302.     * do the refraction redraw hack -- for now, just don't draw it */
  303.     //  if (draw_sphere) glCallList(list_sphere);
  304.  
  305.     for (i = 0; i < nlights; i++)
  306.     {
  307.         if (draw_lights) glCallList(lists_lights + i);
  308.     }
  309. }
  310.  
  311. /* This draws an image of the scene seen through the sphere */
  312. static void scene_draw_refracted()
  313. {
  314.     int i;
  315.  
  316.     if (!draw_sphere) return;
  317.  
  318.  
  319.     /* Draw an image of the sphere into the stencil plane  - 
  320.     * must do this every time in case the lights have moved in front
  321.     * of it */
  322.     glEnable(GL_STENCIL_TEST);
  323.     glClearStencil(0);
  324.     glClear(GL_STENCIL_BUFFER_BIT);
  325.     glStencilFunc(GL_ALWAYS, 0x1, 0x1);
  326.     glStencilOp(GL_REPLACE, GL_KEEP, GL_REPLACE);
  327.  
  328.     glColorMask(0, 0, 0, 0);
  329.  
  330.     glMatrixMode(GL_PROJECTION);
  331.     glLoadIdentity();
  332.     scene_project();
  333.  
  334.     glEnable(GL_DEPTH_TEST);
  335.     glEnable(GL_CULL_FACE);
  336.     glCallList(list_sphere);
  337.     glDisable(GL_CULL_FACE);
  338.     glDisable(GL_DEPTH_TEST);
  339.  
  340.     glColorMask(1, 1, 1, 1);
  341.  
  342.  
  343.     /* Set up a transform with a wider field of view  - this is inaccurate 
  344.     * but I don't have time to do it right */
  345.     glMatrixMode(GL_PROJECTION);
  346.     glLoadIdentity();
  347.     gluPerspective(fov * index, aspect, 0.01, 20.0);
  348.     gluLookAt(eyep[0], eyep[1], eyep[2], lookp[0], lookp[1], lookp[2], 1, 0, 0);
  349.     glMatrixMode(GL_MODELVIEW);
  350.     glLoadIdentity();
  351.  
  352.     /* Set up the stencil stuff which will be used to draw the image */
  353.     glStencilFunc(GL_NOTEQUAL, 0x0, 0xffffffff);
  354.     glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  355.  
  356.     /* Draw the image, gambling that we'll never see anything but the
  357.     * floor through the table */
  358.     glLoadName(name_sphere);
  359.     
  360.     if (draw_texture) glEnable(GL_TEXTURE_2D);
  361.     //if (draw_square) glCallList(list_square);
  362.     square_list_init();
  363.     
  364.     if (draw_shadows)    
  365.     {
  366.         for (i = 0; i < nlights; i++)
  367.         {
  368.             if (lights[i].on) 
  369.             {
  370.                 glPushMatrix();
  371.                 glRotatef(-light_rotation[i], 0, 0, 1);
  372.                 glCallList(lists_shadows + i);
  373.                 glPopMatrix();
  374.             }
  375.         }
  376.     }
  377.     
  378.     if (draw_refraction)
  379.     {
  380.         for (i = 0; i < nlights; i++)
  381.         {
  382.             if (lights[i].on)
  383.             {
  384.                 glPushMatrix();
  385.                 glRotatef(-light_rotation[i], 0, 0, 1);
  386.                 glCallList(lists_refraction + i);
  387.                 glPopMatrix();
  388.             }
  389.         }
  390.     }
  391.     
  392.     glDisable(GL_TEXTURE_2D);
  393.  
  394.     /* Draw the sphere to make it look like it
  395.     * has some substance */
  396.     glMatrixMode(GL_PROJECTION);
  397.     glLoadIdentity();
  398.     scene_project();
  399.     glCallList(list_spheredisk);
  400.  
  401.     glDisable(GL_STENCIL_TEST);
  402. }
  403.  
  404.  
  405. void scene_draw() 
  406. {
  407.     glMatrixMode(GL_PROJECTION);
  408.     glLoadIdentity();
  409.  
  410.     glMatrixMode(GL_MODELVIEW);
  411.     glLoadIdentity();
  412.  
  413.     scene_project();
  414.  
  415.     /* Should draw an image of the square into the stencil buffer 
  416.     * to make sure that refractions which are not on the square do not get
  417.     * drawn, but it can wait. */
  418.  
  419.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  420.     scene_rasterize();
  421.  
  422.     scene_draw_refracted();
  423. }
  424.  
  425. const int pick_maxz = 0xffffffff;
  426.  
  427. int scene_pick(GLdouble x, GLdouble y)
  428. {
  429.     GLuint buffer[128];
  430.     GLint vp[4], nhits, nnames;
  431.     GLuint minz, hit = name_background;
  432.     GLint i, j;
  433.  
  434.     glMatrixMode(GL_MODELVIEW);
  435.     glLoadIdentity();
  436.  
  437.     glMatrixMode(GL_PROJECTION);
  438.     glLoadIdentity();
  439.  
  440.     glGetIntegerv(GL_VIEWPORT, vp);
  441.  
  442.     glSelectBuffer(128, buffer);
  443.     glRenderMode(GL_SELECT);
  444.  
  445.     // Where is this supposed to go, anyway?
  446.     gluPickMatrix(x, vp[3] - y, 1, 1, vp);
  447.  
  448.     scene_project();
  449.  
  450.     glMatrixMode(GL_MODELVIEW);
  451.  
  452.     glInitNames();
  453.     glPushName(name_background);
  454.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  455.     scene_rasterize();
  456.     glFlush();
  457.     nhits = glRenderMode(GL_RENDER);
  458.  
  459.     minz = pick_maxz;
  460.     for (i = j = 0; j < nhits; j++)
  461.     {
  462.         nnames = buffer[i];
  463.         i++;
  464.         if (buffer[i] < minz)
  465.         {
  466.             minz = buffer[i];
  467.             hit = buffer[i + 1 + nnames];
  468.         }
  469.     
  470.         i++;
  471.         i += nnames + 1;
  472.     }
  473.     
  474.     if (minz == pick_maxz) return name_background;
  475.     else return hit;
  476. }
  477.  
  478. void scene_reset_lights() 
  479. {
  480.     int i;
  481.     
  482.     for (i = 0; i < nlights; i++)
  483.     {
  484.         lights[i].pos = light_init_position[i];
  485.         light_rotation[i] = light_init_rotation[i];
  486.     }
  487.     
  488.     lights_init_position();
  489.     lights_list_init2();
  490. }
  491.  
  492. static void square_list_init()
  493. {
  494.     GLfloat x, y, inc;
  495.     int i, j;  
  496.     
  497.     //glNewList(list_square, GL_COMPILE);
  498.     //glLoadName(name_square);
  499.     
  500.     glNormal3f(0, 0, 1);
  501.     glEnable(GL_LIGHTING);
  502.     
  503.     glCallList(list_lights_on);
  504.     
  505.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, square_ambient);
  506.     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, square_diffuse);
  507.     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, square_specular);
  508.     
  509.     inc = 10.0 / diskdiv;
  510.     //glEnable(GL_CULL_FACE);
  511.  
  512.     for (i = 0, y = -5.0; i < diskdiv; i++, y += inc)
  513.     {
  514.         glBegin(GL_TRIANGLE_STRIP);
  515.         
  516.         for (j = 0, x = -5.0; j <= diskdiv; j++, x += inc)
  517.         {
  518.             glTexCoord2f(x, y + inc);
  519.             glVertex2f(x, y + inc);
  520.             glTexCoord2f(x, y);
  521.             glVertex2f(x, y);
  522.         }
  523.         
  524.         glEnd();
  525.     }
  526.  
  527.     glDisable(GL_CULL_FACE);
  528.     glCallList(list_lights_off);
  529.     glDisable(GL_LIGHTING);
  530.     //glEndList();
  531. }
  532.  
  533. static void spheredisk_list_init()
  534. {
  535.     glNewList(list_spheredisk, GL_COMPILE);
  536.     glEnable(GL_BLEND);
  537.     glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
  538.     glEnable(GL_LIGHTING);
  539.     glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
  540.     glEnable(GL_COLOR_MATERIAL);
  541.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, sphere_ambient);
  542.     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, sphere_specular);
  543.     glCallList(list_lights_on);
  544.     sphere_disk.draw();
  545.     glCallList(list_lights_off);
  546.     glDisable(GL_COLOR_MATERIAL);
  547.     glDisable(GL_LIGHTING);
  548.     glDisable(GL_BLEND);
  549.     glEndList();
  550. }
  551.  
  552. void lights_onoff(int light, int val)
  553. {
  554.     lights[light].on = val;
  555.     lights_init_onoff();
  556.     lights_list_init(light);
  557.     square_list_init();
  558. }
  559.  
  560. void refraction_change(GLfloat refraction)
  561. {
  562.     if (refraction == index) return;
  563.     index = refraction;
  564.     shadow_refraction_full_build();
  565.     refraction_list_init();
  566. }
  567.  
  568. void divisions_change(int divisions)
  569. {
  570.     Point_b eye, look;
  571.  
  572.     if (divisions != spherediv)
  573.     {
  574.         spherediv = divisions;
  575.  
  576.         light_draw_list_init();
  577.         lights_list_init2();
  578.  
  579.         sphere_disk.set_divisions(spherediv, spherediv);
  580.         sphere_disk.fill_points();
  581.         sphere_disk.set_colors(white);
  582.         sphere_disk.scale_alpha_by_z();
  583.         eye = eyep;
  584.         look = lookp;
  585.         sphere_disk.face_direction((eye - look).unit());
  586.         sphere_disk.copy_normals_from_points();
  587.         sphere_disk.scale_translate(sphere_size, sphere_position);
  588.         sphere_build();
  589.         sphere_list_init();
  590.  
  591.         diskdiv = divisions;
  592.         disk_build();
  593.         shadow_refraction_full_build();
  594.         square_list_init();
  595.         spheredisk_list_init();
  596.         shadow_list_init();
  597.         refraction_list_init();
  598.     }
  599. }
  600.  
  601. int scene_move(int name, float dr, float dphi, float dtheta, int update)
  602. {
  603.     switch(name)
  604.     {
  605.         case name_background:
  606.             return 0;
  607.         case name_square:
  608.             return 0;
  609.         case name_sphere:
  610.             return 0;
  611.         default:
  612.             if (name < name_lights || name > name_lights + nlights) return 0;
  613.         return lights_move(name - name_lights, dr, dphi, dtheta, update);
  614.     }
  615. }
  616.  
  617. void scene_move_update(int name, int dr, int dphi, int dtheta)
  618. {
  619.     switch(name)
  620.     {
  621.         case name_background:
  622.             break;
  623.         case name_square:
  624.             break;
  625.         case name_sphere:
  626.             break;
  627.         default:
  628.             if (name < name_lights || name > name_lights + nlights) break;
  629.             lights_move_update(name - name_lights, dr, dphi, dtheta);
  630.             break;
  631.     }
  632. }
  633.  
  634.  
  635. static void lights_init_onoff()
  636. {
  637.     int i;
  638.  
  639.     glNewList(list_lights_on, GL_COMPILE);
  640.     
  641.     for (i = 0; i < nlights; i++)
  642.     {
  643.         if (lights[i].on) glEnable(GL_LIGHT0 + i);
  644.         else glDisable(GL_LIGHT0 + i);
  645.     }
  646.     
  647.     glEndList();
  648.  
  649.     glNewList(list_lights_off, GL_COMPILE);
  650.     
  651.     for (i = 0; i < nlights; i++) glDisable(GL_LIGHT0 + i);
  652.     {
  653.         glEndList();
  654.     }
  655. }
  656.  
  657.  
  658.  
  659. static void lights_init_position()
  660. {
  661.     int i;
  662.  
  663.     for (i = 0; i < nlights; i++) lights_init_position(i);
  664. }
  665.  
  666. static void lights_init_position(int i) 
  667. {
  668.     Point_b l, d;
  669.  
  670.     glMatrixMode(GL_MODELVIEW);
  671.     glLoadIdentity();
  672.     glMatrixMode(GL_PROJECTION);
  673.     glLoadIdentity();
  674.  
  675.     l = lights[i].pos;
  676.     l.pt[0] = lights[i].pos.pt[0] * cos(radians(light_rotation[i]));
  677.     l.pt[1] = lights[i].pos.pt[0] * -sin(radians(light_rotation[i]));
  678.     
  679.     d = (sphere_position - l).unit();
  680.     glLightfv(GL_LIGHT0 + i, GL_POSITION, l.pt);
  681.     glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, d.pt);
  682. }
  683.  
  684. static void lights_list_init2(void)
  685. {
  686.     int i;
  687.     for (i = 0; i < nlights; i++) lights_list_init(i);
  688. }
  689.  
  690. static void lights_list_init(int n)
  691. {
  692.     Color c;
  693.  
  694.     glNewList(lists_lights + n, GL_COMPILE);
  695.     
  696.     if (lights[n].on)
  697.     {
  698.         glLoadName(name_lights + n);
  699.  
  700.         glEnable(GL_DEPTH_TEST);
  701.         glEnable(GL_LIGHTING);
  702.         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
  703.         glCallList(list_lights_on);
  704.  
  705.         c = lights[n].diffuse;
  706.         glMaterialfv(GL_BACK, GL_AMBIENT, c.c);
  707.         glMaterialfv(GL_BACK, GL_DIFFUSE, black.c);
  708.         glMaterialfv(GL_BACK, GL_SPECULAR, black.c);
  709.  
  710.         glMaterialfv(GL_FRONT, GL_AMBIENT, (c * .75).c);
  711.         glMaterialfv(GL_FRONT, GL_DIFFUSE, white.c);
  712.         glMaterialfv(GL_FRONT, GL_SPECULAR, white.c);
  713.  
  714.         glMatrixMode(GL_MODELVIEW);
  715.         glPushMatrix();
  716.         glRotatef(-light_rotation[n], 0, 0, 1);
  717.         glTranslatef(lights[n].pos.pt[0], lights[n].pos.pt[1], 
  718.         lights[n].pos.pt[2]);
  719.         glRotatef(-degrees(atan2(lights[n].pos.pt[2] - sphere_position.pt[2],
  720.         lights[n].pos.pt[0])), 0, 1, 0);
  721.         glCallList(list_light_draw);
  722.         glPopMatrix();
  723.  
  724.         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
  725.         glDisable(GL_LIGHTING);
  726.         glCallList(list_lights_off);
  727.         glDisable(GL_DEPTH_TEST);
  728.     }
  729.     else
  730.     {
  731.         /* 5.0.1 for Elans seems to object strongly to replacing
  732.         * empty display lists, so will put some stupid command
  733.         * in here */
  734.         glColor3f(0, 0, 0);
  735.     }
  736.     
  737.     glEndList();
  738. }
  739.  
  740. static void light_draw_list_init()
  741. {
  742.     float c, s;
  743.     int t;
  744.  
  745.     glNewList(list_light_draw, GL_COMPILE);
  746.     glEnable(GL_NORMALIZE);
  747.     glMatrixMode(GL_MODELVIEW);
  748.     glPushMatrix();
  749.     glScalef(.25, .15, .15);
  750.     glBegin(GL_QUAD_STRIP);
  751.     
  752.     for (t = 0; t <= spherediv; t++)
  753.     {
  754.         c = cos(M_2PI * (float)t / (float)spherediv);
  755.         s = sin(M_2PI * (float)t / (float)spherediv);
  756.         glNormal3f(.25, .968*s, .968*c);
  757.         glVertex3f(0, s, c);
  758.         glVertex3f(1, .75*s, .75*c);
  759.     }
  760.     
  761.     glEnd();
  762.     glNormal3f(1, 0, 0);
  763.     glBegin(GL_TRIANGLE_STRIP);
  764.     
  765.     for (t = 0; t <= spherediv; t++)
  766.     {
  767.         c = cos(M_2PI * (float)t / (float)spherediv);
  768.         s = sin(M_2PI * (float)t / (float)spherediv);
  769.         glVertex3f(1, .75*s, .75*c);
  770.         glVertex3f(1, 0, 0);
  771.     }
  772.     
  773.     glEnd();
  774.     glPopMatrix();
  775.     glDisable(GL_NORMALIZE);
  776.     glEndList();
  777. }
  778.  
  779. static void lights_init()
  780. {
  781.     int i;
  782.  
  783.     for (i = 0; i < nlights; i++)
  784.     {
  785.         glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, lights[i].diffuse);
  786.         glLightfv(GL_LIGHT0 + i, GL_SPECULAR, black.c);
  787.         glLightfv(GL_LIGHT0 + i, GL_AMBIENT, black.c);
  788.         glLightf(GL_LIGHT0 + i, GL_SPOT_EXPONENT, 4);
  789.         glLightf(GL_LIGHT0 + i, GL_SPOT_CUTOFF, 90);
  790.     }
  791.  
  792.     glLightfv(GL_LIGHT0 + nlights, GL_DIFFUSE, black.c);
  793.     glLightfv(GL_LIGHT0 + nlights, GL_SPECULAR, black.c);
  794.     glLightfv(GL_LIGHT0 + nlights, GL_AMBIENT, world_ambient.c);
  795.     glEnable(GL_LIGHT0 + nlights);
  796.  
  797.     /* GL_LIGHT0 + nlights + 1 willl eventually be used to draw the 
  798.     * refractions - stay tuned. */
  799.     glLightfv(GL_LIGHT0 + nlights + 1, GL_DIFFUSE, black.c);
  800.     glLightfv(GL_LIGHT0 + nlights + 1, GL_SPECULAR, black.c);
  801.     glLightfv(GL_LIGHT0 + nlights + 1, GL_AMBIENT, white.c);
  802. }
  803.  
  804. static int lights_move(int light, float dr, float dphi, float dtheta, int update)
  805. {
  806.     float cphi, sphi, x, y;
  807.     Point_b l, dl;
  808.  
  809.     if (!(dr || dphi || dtheta)) return 0;
  810.  
  811.     l = lights[light].pos - sphere_position;
  812.  
  813.     if (dr)
  814.     {
  815.         dl = l + l*dr;
  816.         if (dl.mag() > sphere_size) l = dl;
  817.     }
  818.  
  819.     if (dphi)
  820.     {
  821.         cphi = cos(dphi);
  822.         sphi = sin(dphi);
  823.         y = -l.pt[0]*sphi + l.pt[2]*cphi;
  824.  
  825.         /* This hack keeps with light from getting below the sphere - 
  826.         * the projection sections would completely freak if this ever
  827.         * happened  - sphere_size is multiplied by two as a fudge factor*/
  828.         if (y < 2.0*sphere_size)
  829.         {
  830.             dphi = atan2(l.pt[2] - 2.0*sphere_size, l.pt[0]);
  831.             cphi = cos(dphi);
  832.             sphi = sin(dphi);
  833.         }
  834.         
  835.         x = l.pt[0];
  836.         l.pt[0] = x*cphi + l.pt[2]*sphi;
  837.         l.pt[2] = -x*sphi + l.pt[2]*cphi;
  838.     }
  839.  
  840.     if (dtheta)
  841.     {
  842.         light_rotation[light] += degrees(dtheta);
  843.         light_rotation[light] = degrees_clamp(light_rotation[light]);
  844.     }
  845.  
  846.     lights[light].pos = l + sphere_position;
  847.     lights[light].pos.pt[3] = 1;
  848.  
  849.     lights_init_position(light);
  850.     lights_list_init(light);
  851.  
  852.     if (update) lights_move_update(light, dr ? 1 : 0, dphi ? 1 : 0, 
  853.     dtheta ? 1 : 0);
  854.     return 1;
  855. }
  856.  
  857. static void lights_move_update(int light, int dr, int dphi, int dtheta)
  858. {
  859.     if (dr)
  860.     {
  861.         disk_build(light);
  862.         shadow_refraction_full_build(light);
  863.         shadow_list_init(light);
  864.         refraction_list_init(light);  
  865.     }
  866.     else if (dphi)
  867.     {
  868.         shadow_refraction_full_build(light);
  869.         shadow_list_init(light);
  870.         refraction_list_init(light);
  871.     }
  872.     else if (dtheta)
  873.     {
  874.     }
  875.  
  876. }
  877.  
  878.  
  879. static int get_lists(int size)
  880. {
  881.     int i;
  882.     i = glGenLists(size);
  883.     
  884.     if (size && !i)
  885.     {
  886.         fprintf(stderr, "Unable to allocate %d display lists.\n");
  887.         exit(1);
  888.     }
  889.     
  890.     return i;
  891. }
  892.  
  893. static void lists_init()
  894. {
  895.     //list_square = get_lists(1);
  896.     lists_shadows = get_lists(nlights);
  897.     lists_refraction = get_lists(nlights);
  898.     lists_lights = get_lists(nlights);
  899.     list_sphere = get_lists(1);
  900.     list_spheredisk = get_lists(1);
  901.     list_lights_on = get_lists(1);
  902.     list_lights_off = get_lists(1);
  903.     list_light_draw = get_lists(1);
  904.  
  905.     // sphere_build();
  906. }
  907.  
  908. static inline int sphere_npoints() 
  909. {
  910.     return (spherediv+1)*spherediv*3;
  911. }
  912.  
  913. void sphere_build()
  914. {
  915.     int nspherepts;
  916.     int r, t, index;
  917.     float c, s;
  918.  
  919.     delete spherepts;
  920.     nspherepts = sphere_npoints();
  921.     if (nspherepts == 0) return;
  922.     spherepts = new GLfloat[nspherepts];
  923.  
  924.     index = 0;
  925.     for (r = 0; r <= spherediv; r++)
  926.     {
  927.         spherepts[index++] = sin(M_PI * (float)r / (float)spherediv);
  928.         spherepts[index++] = 0;
  929.         spherepts[index++] = -cos(M_PI * (float)r / (float)spherediv);
  930.     }
  931.     
  932.     for (t = 1; t < spherediv; t++)
  933.     {
  934.         c = cos(2.0 * M_PI * (float)t / (float)spherediv);
  935.         s = sin(2.0 * M_PI * (float)t / (float)spherediv);
  936.     
  937.         for (r = 0; r <= spherediv; r++)
  938.         {
  939.             spherepts[index++] = c*spherepts[r*3];
  940.             spherepts[index++] = s*spherepts[r*3];
  941.             spherepts[index++] = spherepts[r*3 + 2];
  942.         }
  943.     }
  944. }
  945.  
  946. void sphere_list_init()
  947. {
  948.     glNewList(list_sphere, GL_COMPILE);
  949.     sphere_disk.draw_by_perimeter();
  950.     glEndList();
  951. }  
  952.  
  953. void sphere_draw()
  954. {
  955.     int r, t, p1, p2;
  956.  
  957.     for (t = 1; t < spherediv; t++)
  958.     {
  959.         glBegin(GL_QUAD_STRIP);
  960.         p1 = (t - 1) * (spherediv + 1);
  961.         p2 = t * (spherediv + 1);
  962.         
  963.         for (r = 0; r <= spherediv; r++, p1++, p2++)
  964.         {
  965.             glNormal3fv(&spherepts[p1*3]);
  966.             glVertex3fv(&spherepts[p1*3]);
  967.             glNormal3fv(&spherepts[p2*3]);
  968.             glVertex3fv(&spherepts[p2*3]);
  969.         }
  970.         
  971.         glEnd();
  972.     }
  973.  
  974.     glBegin(GL_QUAD_STRIP);
  975.     p1 = (spherediv + 1) * (spherediv - 1);
  976.     p2 = 0;
  977.     
  978.     for (r = 0; r <= spherediv; r++, p1++, p2++)
  979.     {
  980.         glNormal3fv(&spherepts[p1*3]);
  981.         glVertex3fv(&spherepts[p1*3]);
  982.         glNormal3fv(&spherepts[p2*3]);
  983.         glVertex3fv(&spherepts[p2*3]);
  984.     }
  985.     glEnd();
  986. }
  987.  
  988. static void disk_build()
  989. {
  990.     int i;
  991.     for (i = 0; i < nlights; i++) disk_build(i);
  992. }
  993.  
  994. static void disk_build(int disk)
  995. {
  996.     Point_b light;
  997.     light = lights[disk].pos;
  998.  
  999.     disks[disk].free_points_normals();
  1000.     disks[disk].free_colors();
  1001.  
  1002.     disks[disk].set_divisions(diskdiv, diskdiv);
  1003.     disks[disk].set_angle(2.0 * 
  1004.     acos(sphere_size / light.dist(sphere_position)));
  1005.     disks[disk].fill_points();
  1006. }
  1007.  
  1008. static void shadow_list_init()
  1009. {
  1010.     int i;
  1011.     for (i = 0; i < nlights; i++) shadow_list_init(i);
  1012. }
  1013.  
  1014. static void shadow_list_init(int n)
  1015. {
  1016.     Color c(square_ambient[0], square_ambient[1], square_ambient[2]);
  1017.  
  1018.     c *= world_ambient;
  1019.  
  1020.     glNewList(lists_shadows + n, GL_COMPILE);
  1021.     glColorMask(lights[n].shadow_mask[0], lights[n].shadow_mask[1],
  1022.     lights[n].shadow_mask[2], lights[n].shadow_mask[3]);
  1023.     glDisable(GL_DEPTH_TEST);
  1024.     glColor3fv(c.c);
  1025.     shadows[n].draw_by_perimeter(0, 0, 1);
  1026.     glColorMask(1, 1, 1, 1);
  1027.     glEndList();
  1028. }
  1029.  
  1030. static void refraction_list_init()
  1031. {
  1032.     int i;
  1033.     for (i = 0; i < nlights; i++) refraction_list_init(i);
  1034. }
  1035.  
  1036. static void refraction_list_init(int n)
  1037. {
  1038.     /* This could be loads simpler if it weren't for the texture mapping -
  1039.     * that's where all this weirdness with GL_LIGHT0 + nlights + 1 comes 
  1040.     * in */
  1041.     glNewList(lists_refraction + n, GL_COMPILE);
  1042.  
  1043.     glEnable(GL_LIGHTING);
  1044.     glCallList(list_lights_off);
  1045.     /* This is white ambient light */
  1046.     glEnable(GL_LIGHT0 + nlights + 1);
  1047.     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, black.c);
  1048.     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black.c);
  1049.     glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT);
  1050.     glEnable(GL_COLOR_MATERIAL);
  1051.  
  1052.     glBlendFunc(GL_ONE, GL_ONE);
  1053.     glEnable(GL_BLEND);
  1054.  
  1055.     glDisable(GL_DEPTH_TEST);
  1056.     refraction[n].draw();
  1057.  
  1058.     glDisable(GL_BLEND);
  1059.  
  1060.     glDisable(GL_COLOR_MATERIAL);
  1061.     glDisable(GL_LIGHT0 + nlights + 1);
  1062.     glDisable(GL_LIGHTING);
  1063.  
  1064.     glEndList();
  1065. }
  1066.  
  1067. static void shadow_refraction_full_build()
  1068. {
  1069.     int i;
  1070.     for (i = 0; i < nlights; i++) shadow_refraction_full_build(i);
  1071. }
  1072.  
  1073. /* This entire function is written a bit oddly... */
  1074. static void shadow_refraction_full_build(int n)
  1075. {
  1076.     Color c;
  1077.     float dist_light;
  1078.     Point_b dlight, zaxis;
  1079.  
  1080.     /* Make sure that we're starting over from scratch */
  1081.     shadows[n].free_points_normals();
  1082.     shadows[n].free_colors();
  1083.     refraction[n].free_points_normals();
  1084.     refraction[n].free_colors();
  1085.  
  1086.     dlight = lights[n].pos - sphere_position;
  1087.     dist_light = dlight.mag();
  1088.     dlight.unitize();
  1089.     zaxis.pt[0] = 0;
  1090.     zaxis.pt[1] = 0;
  1091.     zaxis.pt[2] = 1;
  1092.  
  1093.     shadows[n].set_divisions(disks[n].get_rdivisions(), 
  1094.     disks[n].get_tdivisions());
  1095.     refraction[n].set_divisions(disks[n].get_rdivisions(), 
  1096.     disks[n].get_tdivisions());
  1097.  
  1098.     shadows[n].alloc_points();
  1099.     shadows[n].face_direction(dlight, disks[n]);
  1100.     shadows[n].scale_translate(sphere_size, sphere_position);
  1101.  
  1102.     c = square_diffuse;
  1103.     c *= lights[n].diffuse; 
  1104.  
  1105.     refraction[n].copy_points(disks[n]);
  1106.     refraction[n].set_colors(c);
  1107.     refraction[n].scale_colors_by_z();
  1108.  
  1109.     refraction[n].scale(sphere_size);
  1110.     refraction[n].refract_normals(zaxis * dist_light, index);
  1111.     refraction[n].face_direction(dlight);
  1112.  
  1113.     refraction[n].project_borrow_points(shadows[n]);  
  1114.     refraction[n].free_normals();
  1115.     shadows[n].project(lights[n].pos);
  1116.     if (index != 1.0) refraction[n].scale_colors_by_darea(shadows[n]);
  1117. }
  1118.  
  1119. int scene_load_texture(char *texfile)
  1120. {
  1121.     teximage = tkRGBImageLoad(texfile);
  1122.  
  1123.     if (teximage == NULL) return 0;
  1124.     else return 1;
  1125.  
  1126.     return 0;
  1127. }
  1128.  
  1129. void texture_init()
  1130. {
  1131.     if (teximage == NULL) return;
  1132.  
  1133.     gluBuild2DMipmaps(GL_TEXTURE_2D, 3, teximage->sizeX, teximage->sizeY,
  1134.     GL_RGB, GL_UNSIGNED_BYTE, (const void *) teximage->data);
  1135.  
  1136.     glMatrixMode(GL_TEXTURE);
  1137.     glLoadIdentity();
  1138.     glRotatef(90, 0, 0, 1);
  1139.  
  1140.     glTranslatef(.5, .5, 0);
  1141.     glScalef(.1, .1, 1);
  1142.     glMatrixMode(GL_MODELVIEW);
  1143.  
  1144.     //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
  1145.     //GL_NEAREST_MIPMAP_NEAREST);
  1146.     //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
  1147.     //GL_LINEAR);
  1148.     
  1149.     /* New */
  1150.     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  1151.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  1152.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  1153. }
  1154.